package com.hb.trade.server.project.evaluation.controller;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.hb.core.pojo.project.evaluation.dto.*;
import com.hb.core.pojo.project.evaluation.entity.EvaluationSummary;
import com.hb.core.pojo.project.evaluation.entity.EvaluationThird;
import com.hb.core.pojo.project.evaluation.vo.*;
import com.hb.core.pojo.project.section.entity.BidSection;
import com.hb.trade.server.project.evaluation.service.EvaluationSecondService;
import com.hb.trade.server.project.evaluation.service.EvaluationService;
import com.hb.trade.server.project.evaluation.service.EvaluationSummaryService;
import com.hb.trade.server.project.evaluation.service.EvaluationThirdService;
import com.hb.trade.server.project.section.service.raw.BidSectionService;
import io.swagger.annotations.ApiOperation;
import org.fzzn.core.model.enums.LogicEnum;
import org.fzzn.core.model.msg.Message;
import org.fzzn.core.model.msg.ResponseDto;
import org.fzzn.core.util.MsgUtil;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 专家二级评审表 前端控制器
 * </p>
 *
 * @author jinhaolin
 * @since 2022-04-13
 */
@RestController
public class EvaluationController {

    protected final EvaluationThirdService evaluationThirdService;
    protected final EvaluationService evaluationService;
    protected final EvaluationSecondService evaluationSecondService;
    protected final EvaluationSummaryService evaluationSummaryService;
    protected final BidSectionService bidSectionService;

    public EvaluationController(EvaluationThirdService evaluationThirdService,
                                EvaluationService evaluationService,
                                EvaluationSecondService evaluationSecondService,
                                EvaluationSummaryService evaluationSummaryService,
                                BidSectionService bidSectionService) {
        this.evaluationThirdService = evaluationThirdService;
        this.evaluationService = evaluationService;
        this.evaluationSecondService = evaluationSecondService;
        this.evaluationSummaryService = evaluationSummaryService;
        this.bidSectionService = bidSectionService;
    }

    /**
     * 获取评审项下的所有评审点的评审结果
     * @param evaluationReviewItemParam
     * @return
     */
    @PostMapping("/evaluation/allResultOfReviewPoint")
    public Message<EvaluationReviewItemResultVO> allResultOfReviewPoint(@RequestBody EvaluationReviewItemParam evaluationReviewItemParam) {

        Long expertId = evaluationReviewItemParam.getExpertId();
        String expertName = evaluationReviewItemParam.getExpertName();
        Long reviewItemId = evaluationReviewItemParam.getReviewItemId();
        Long sectionId = evaluationReviewItemParam.getSectionId();

        // 判断该评审项节点的数据是否可操作
        Boolean canNodeModify = evaluationService.canNodeDataModify(sectionId, reviewItemId, expertId);
        if (!canNodeModify) {
            return MsgUtil.fail("请先完成前面评审项的汇总");
        }

        synchronized (this) {
            // 初始化表数据
            evaluationService.initEvaluationDataForExpert(sectionId, reviewItemId, expertId, expertName);

            // 初始化淘汰状态
            evaluationService.initOrgEliminateStatus(sectionId, reviewItemId, expertId);
        }

        EvaluationReviewItemResultVO evaluationReviewItemResultVO = evaluationThirdService.allResultOfReviewPoint(evaluationReviewItemParam);

        return MsgUtil.success(evaluationReviewItemResultVO);
    }

    /**
     * 检查提交数据是否有已汇总的状态，已汇总的数据不允许再次提交
     * @param params
     * @return
     */
    private Boolean checkHaveSummaryData(List<EvaluationSubmitScoreParam> params) {
        List<Long> idList= new ArrayList<>();
        for (EvaluationSubmitScoreParam param : params) {
            idList.add(param.getId());
        }
        return evaluationThirdService.evaluationThirdHaveSummaryData(idList);
    }

    /**
     * 批量通过
     * @param evaluationSubmitScoreParamList
     * @return
     */
    @PostMapping("/evaluation/batchPass")
    public Message<Boolean> batchPass(@RequestBody List<EvaluationSubmitScoreParam> evaluationSubmitScoreParamList) {
        // 判断数据是否已汇总，已汇总状态不允许修改
        Boolean haveSummary = checkHaveSummaryData(evaluationSubmitScoreParamList);
        if (haveSummary) {
            return MsgUtil.fail("已汇总数据不允许修改");
        }

        Boolean result = evaluationThirdService.batchPass(evaluationSubmitScoreParamList);
        return MsgUtil.success(result);
    }

    /**
     * 批量拒绝
     * @param evaluationSubmitScoreParamList
     * @return
     */
    @PostMapping("/evaluation/batchRefuse")
    public Message<Boolean> batchRefuse(@RequestBody List<EvaluationSubmitScoreParam> evaluationSubmitScoreParamList) {
        // 判断数据是否已汇总，已汇总状态不允许修改
        Boolean haveSummary = checkHaveSummaryData(evaluationSubmitScoreParamList);
        if (haveSummary) {
            return MsgUtil.fail("已汇总数据不允许修改");
        }

        Boolean result = evaluationThirdService.batchRefuse(evaluationSubmitScoreParamList);
        return MsgUtil.success(result);
    }

    /**
     * 保存单个企业的单个评审点的评标结果
     * @return
     */
    @PostMapping("/evaluation/saveScoreOfReviewPointSingleOrg")
    public Message<Boolean> saveScoreOfReviewPointSingleOrg(@RequestBody EvaluationSubmitScoreParam evaluationSubmitScoreParam) {
        // 判断数据是否已汇总，已汇总状态不允许修改
        List<EvaluationSubmitScoreParam> paramList = new ArrayList<>();
        paramList.add(evaluationSubmitScoreParam);
        Boolean haveSummary = checkHaveSummaryData(paramList);
        if (haveSummary) {
            return MsgUtil.fail("已汇总数据不允许修改");
        }

        // 判断该评审项节点的数据是否可操作
        EvaluationThird evaluationThird = evaluationThirdService.getById(evaluationSubmitScoreParam.getId());
        Boolean canNodeModify = evaluationService.canNodeDataModify(evaluationThird.getSectionId(), evaluationThird.getSecondReviewItemId(), evaluationThird.getExpertId());
        if (!canNodeModify) {
            return MsgUtil.fail("请先完成前面评审项的汇总");
        }

        Boolean save = evaluationThirdService.saveScoreOfReviewPointSingleOrg(evaluationSubmitScoreParam);
        return MsgUtil.success(save);
    }

    /**
     * 保存批量评标结果
     * @param evaluationSubmitScoreParamList
     * @return
     */
    @PostMapping("/evaluation/saveScoreBatch")
    public Message<Boolean> saveScoreBatch(@RequestBody List<EvaluationSubmitScoreParam> evaluationSubmitScoreParamList) {
        // 判断数据是否已汇总，已汇总状态不允许修改
        Boolean haveSummary = checkHaveSummaryData(evaluationSubmitScoreParamList);
        if (haveSummary) {
            return MsgUtil.fail("已汇总数据不允许修改");
        }

        // 判断该评审项节点的数据是否可操作
        EvaluationThird evaluationThird = evaluationThirdService.getById(evaluationSubmitScoreParamList.get(0).getId());
        Boolean canNodeModify = evaluationService.canNodeDataModify(evaluationThird.getSectionId(), evaluationThird.getSecondReviewItemId(), evaluationThird.getExpertId());
        if (!canNodeModify) {
            return MsgUtil.fail("请先完成前面评审项的汇总");
        }

        Boolean save = evaluationThirdService.saveScoreBatch(evaluationSubmitScoreParamList);
        return MsgUtil.success(save);
    }

    /**
     * 提交单个评审点的评标结果
     * @return
     */
    @PostMapping("/evaluation/submitScoreOfReviewPoint")
    public Message<Boolean> submitScoreOfReviewPoint(@RequestBody List<EvaluationSubmitScoreParam> evaluationSubmitScoreParamList) {
        // 判断数据是否已汇总，已汇总状态不允许修改
        Boolean haveSummary = checkHaveSummaryData(evaluationSubmitScoreParamList);
        if (haveSummary) {
            return MsgUtil.fail("已汇总数据不允许修改");
        }

        // 判断该评审项节点的数据是否可操作
        EvaluationThird evaluationThird = evaluationThirdService.getById(evaluationSubmitScoreParamList.get(0).getId());
        Boolean canNodeModify = evaluationService.canNodeDataModify(evaluationThird.getSectionId(), evaluationThird.getSecondReviewItemId(), evaluationThird.getExpertId());
        if (!canNodeModify) {
            return MsgUtil.fail("请先完成前面评审项的汇总");
        }

        Boolean save = evaluationThirdService.submitScoreOfReviewPoint(evaluationSubmitScoreParamList);
        return MsgUtil.success(save);
    }

    /**
     * 提交单个评审点的评标结果（组长对报价评审）
     * @return
     */
    @PostMapping("/evaluation/submitScoreOfReviewPointByOffer")
    public Message<Boolean> submitScoreOfReviewPointByOffer(@RequestBody List<EvaluationSubmitScoreParam> evaluationSubmitScoreParamList) {
        // 判断数据是否已汇总，已汇总状态不允许修改
        Boolean haveSummary = checkHaveSummaryData(evaluationSubmitScoreParamList);
        if (haveSummary) {
            return MsgUtil.fail("已汇总数据不允许修改");
        }

        // 判断该评审项节点的数据是否可操作
        EvaluationThird evaluationThird = evaluationThirdService.getById(evaluationSubmitScoreParamList.get(0).getId());
        Boolean canNodeModify = evaluationService.canNodeDataModify(evaluationThird.getSectionId(), evaluationThird.getSecondReviewItemId(), evaluationThird.getExpertId());
        if (!canNodeModify) {
            return MsgUtil.fail("请先完成前面评审项的汇总");
        }

        // 三级评审id
        Long evaluationThirdId = evaluationSubmitScoreParamList.get(0).getId();

        // 修改全部专家的评审状态为待评审（因为组长二次提交时有的专家已经确认）
        evaluationThirdService.editEvaluationStatusByOfferReview(evaluationThirdId);

        Boolean save = evaluationThirdService.submitScoreOfReviewPoint(evaluationSubmitScoreParamList);
        return MsgUtil.success(save);
    }

    /**
     * 提交并共享单个评审点的评标结果
     * @return
     */
    @PostMapping("/evaluation/submitAndShareScoreOfReviewPoint")
    public Message<Boolean> submitAndShareScoreOfReviewPoint(@RequestBody List<EvaluationSubmitScoreParam> evaluationSubmitScoreParamList) {
        // 判断数据是否已汇总，已汇总状态不允许修改
        Boolean haveSummary = checkHaveSummaryData(evaluationSubmitScoreParamList);
        if (haveSummary) {
            return MsgUtil.fail("已汇总数据不允许修改");
        }

        // 判断该评审项节点的数据是否可操作
        EvaluationThird evaluationThird = evaluationThirdService.getById(evaluationSubmitScoreParamList.get(0).getId());
        Boolean canNodeModify = evaluationService.canNodeDataModify(evaluationThird.getSectionId(), evaluationThird.getSecondReviewItemId(), evaluationThird.getExpertId());
        if (!canNodeModify) {
            return MsgUtil.fail("请先完成前面评审项的汇总");
        }

        Boolean save = evaluationThirdService.submitAndShareScoreOfReviewPoint(evaluationSubmitScoreParamList);
        return MsgUtil.success(save);
    }

    /**
     * 提交评审项下所有评审点的评标结果
     * @return
     */
    @PostMapping("/evaluation/submitScoreOfReviewItem")
    public Message<Boolean> submitScoreOfReviewItem(@RequestBody List<EvaluationSubmitScoreParam> evaluationSubmitScoreParamList) {
        // 判断数据是否已汇总，已汇总状态不允许修改
        Boolean haveSummary = checkHaveSummaryData(evaluationSubmitScoreParamList);
        if (haveSummary) {
            return MsgUtil.fail("已汇总数据不允许修改");
        }

        // 判断该评审项节点的数据是否可操作
        EvaluationThird evaluationThird = evaluationThirdService.getById(evaluationSubmitScoreParamList.get(0).getId());
        Boolean canNodeModify = evaluationService.canNodeDataModify(evaluationThird.getSectionId(), evaluationThird.getSecondReviewItemId(), evaluationThird.getExpertId());
        if (!canNodeModify) {
            return MsgUtil.fail("请先完成前面评审项的汇总");
        }

        Boolean save = evaluationThirdService.submitScoreOfReviewItem(evaluationSubmitScoreParamList);
        return MsgUtil.success(save);
    }

    /**
     * 获取项目及标段信息
     * @param evaluationBidSectionParam
     * @return
     */
    @PostMapping("/evaluation/bidProjectAndSectionInfo")
    public Message<EvaluationProjectAndSectionInfoVO> bidProjectAndSectionInfo(@RequestBody EvaluationBidSectionParam evaluationBidSectionParam) {
        EvaluationProjectAndSectionInfoVO evaluationProjectAndSectionInfoVO = evaluationService.bidProjectAndSectionInfo(evaluationBidSectionParam);
        return MsgUtil.success(evaluationProjectAndSectionInfoVO);
    }

    /**
     * 获取评标流程节点
     * @param evaluationBidSectionParam
     * @return
     */
    @PostMapping("/evaluation/reviewItemFlowNodes")
    public Message<EvaluationReviewItemFlowNodesVO> reviewItemFlowNodes(@RequestBody EvaluationBidSectionParam evaluationBidSectionParam) {
        EvaluationReviewItemFlowNodesVO evaluationReviewItemFlowNodesVO = evaluationService.reviewItemFlowNodes(evaluationBidSectionParam);
        return MsgUtil.success(evaluationReviewItemFlowNodesVO);
    }

    /**
     * 获取线下评标流程节点
     * @param evaluationBidSectionParam
     * @return
     */
    @PostMapping("/evaluation/reviewItemFlowNodesOffline")
    public Message<EvaluationReviewItemFlowNodesVO> reviewItemFlowNodesOffline(@RequestBody EvaluationBidSectionParam evaluationBidSectionParam) {
        EvaluationReviewItemFlowNodesVO evaluationReviewItemFlowNodesVO = evaluationService.reviewItemFlowNodesOffline(evaluationBidSectionParam);
        return MsgUtil.success(evaluationReviewItemFlowNodesVO);
    }

    /**
     * 获取可复用评审信息
     * @param evaluationReviewPointParam
     * @return
     */
    @PostMapping("/evaluation/reusableScoreOfReviewPoint")
    public Message<List<EvaluationReusableScoreItemVO>> reusableScoreOfReviewPoint(@RequestBody EvaluationReviewPointParam evaluationReviewPointParam) {
        List<EvaluationReusableScoreItemVO> evaluationReusableScoreItemVOList = evaluationThirdService.reusableScoreOfReviewPoint(evaluationReviewPointParam);
        return MsgUtil.success(evaluationReusableScoreItemVOList);
    }

    /**
     * 获取汇总结果
     * @param evaluationReviewItemParam
     * @return
     */
    @PostMapping("/evaluation/resultSummaryInfo")
    public Message<EvaluationResultSummaryVO> resultSummaryInfo(@RequestBody EvaluationReviewItemParam evaluationReviewItemParam) {
        Long expertId = evaluationReviewItemParam.getExpertId();
        String expertName = evaluationReviewItemParam.getExpertName();
        Long reviewItemId = evaluationReviewItemParam.getReviewItemId();
        Long sectionId = evaluationReviewItemParam.getSectionId();

        // 判断该评审项节点的数据是否可操作
        Boolean canNodeModify = evaluationService.canNodeDataModify(sectionId, reviewItemId, expertId);
        if (!canNodeModify) {
            return MsgUtil.fail("请先完成前面评审项的汇总");
        }

        synchronized (this) {
            // 初始化表数据
            evaluationService.initEvaluationDataForExpert(sectionId, reviewItemId, expertId, expertName);

            // 初始化淘汰状态
            evaluationService.initOrgEliminateStatus(sectionId, reviewItemId, expertId);
        }

        EvaluationResultSummaryVO evaluationResultSummaryVO = evaluationSecondService.resultSummaryInfo(evaluationReviewItemParam);

        return MsgUtil.success(evaluationResultSummaryVO);
    }

    /**
     * 确认汇总
     * @param evaluationReviewItemParam
     * @return
     */
    @PostMapping("/evaluation/confirmResultSummary")
    public Message<Boolean> confirmResultSummary(@RequestBody EvaluationReviewItemParam evaluationReviewItemParam) {
        Boolean isCan = evaluationSecondService.canResultSummary(evaluationReviewItemParam);
        if (!isCan) {
            return MsgUtil.fail("存在未汇总评审项");
        }
        Boolean result1 = evaluationSecondService.confirmResultSummary(evaluationReviewItemParam);
        Boolean result2 = evaluationThirdService.confirmResultSummary(evaluationReviewItemParam);
        return MsgUtil.success(result1 && result2);
    }

    /**
     * 复核
     * @param evaluationReviewItemParam
     * @return
     */
    @PostMapping("/evaluation/recheckResultSummary")
    public Message<Boolean> recheckResultSummary(@RequestBody EvaluationReviewItemParam evaluationReviewItemParam) {
        Long sectionId = evaluationReviewItemParam.getSectionId();
        Long reviewItemId = evaluationReviewItemParam.getReviewItemId();
        Long expertId = evaluationReviewItemParam.getExpertId();

        // 判断评标是否结束，结束评标后不允许再复核
        EvaluationSummary evaluationSummary = evaluationSummaryService.getEvaluationSummaryBySectionId(sectionId);
        if (evaluationSummary.getEvaluationStatus().equals(2)) {
            return MsgUtil.fail("评标已结束，无法进行复核");
        }

        // 复核判断于操作
        evaluationService.recheckResultSummary(sectionId, reviewItemId, expertId);

        return MsgUtil.success(true);
    }

    /**
     *
     * @Description:更新表格的汇总状态
     * @Author: zhongdl
     * @Date:2022/4/22 10:09
     * @param evaluationSummaryAddDTO:
     * @return: {@link Message< Boolean> }
     **/
    @PostMapping("/evaluation/updateEvaluationSummaryStatus")
    public Message<Boolean> updateEvaluationSummaryStatus(@RequestBody EvaluationSummaryAddDTO evaluationSummaryAddDTO){
        EvaluationSummary evaluationSummary = evaluationSummaryAddDTO.to(EvaluationSummary.class);
        EvaluationSummary summaryDB = evaluationSummaryService.getEvaluationSummaryBySectionId(evaluationSummaryAddDTO.getSectionId());
        if (summaryDB == null || summaryDB.getId() == null){
            return MsgUtil.fail("表格信息不存在");
        }
        evaluationSummary.setId(summaryDB.getId());
        if (StrUtil.isNotEmpty(evaluationSummary.getFinalSheetUrl()) || StrUtil.isNotEmpty(evaluationSummary.getSheetUrl())){
            evaluationSummary.setSheetStatus(LogicEnum.YES.getCode());
        }
        if (StrUtil.isNotEmpty(evaluationSummary.getReportUrl()) || StrUtil.isNotEmpty(evaluationSummary.getFinalReportUrl())){
            evaluationSummary.setReportStatus(LogicEnum.YES.getCode());
        }
        evaluationSummary.buildBaseData(2);
        boolean update = evaluationSummaryService.updateById(evaluationSummary);
        return MsgUtil.success(update);

    }

    /**
     *
     * @Description:专家汇总详情
     * @Author: zhongdl
     * @Date:2022/4/22 10:18
     * @param evaluationSummaryAddDTO:
     * @return: {@link Message< EvaluationSummaryDTO> }
     **/
    @PostMapping("/evaluation/evaluationSummaryDetails")
    public Message<EvaluationSummaryDTO> evaluationSummaryDetails(@RequestBody EvaluationSummaryAddDTO evaluationSummaryAddDTO){
        EvaluationSummaryDTO evaluationSummaryDTO = new EvaluationSummaryDTO();
        EvaluationSummary summaryDB = evaluationSummaryService.getEvaluationSummaryBySectionId(evaluationSummaryAddDTO.getSectionId());
        if (summaryDB == null){
            return MsgUtil.success(evaluationSummaryDTO);
        }
        summaryDB.to(evaluationSummaryDTO);
        //查询是否汇总结束(评标结束)
        int evaluationStatusCount = evaluationSecondService.getEvaluationStatusCount(summaryDB.getSectionId(), CollUtil.list(false, 0, 1));
        evaluationSummaryDTO.setSummaryFlag(evaluationStatusCount > 0 ? LogicEnum.NO.getCode() : LogicEnum.YES.getCode());
        return MsgUtil.success(evaluationSummaryDTO);
    }

    /**
     * 查询报价评审
     *
     * @param evaluationReviewItemParam
     * @return org.fzzn.core.model.msg.Message<java.util.Map>
     * @author tian
     * @date 2022-4-20 15:09
     */
    @PostMapping("/evaluation/findQuotationReview")
    public Message<Map> findQuotationReview(@RequestBody EvaluationReviewItemParam evaluationReviewItemParam) {
        return evaluationThirdService.findQuotationReview(evaluationReviewItemParam);
    }


    /**
     * 非组长 确认报价
     *
     * @param evaluationReviewItemParam
     * @return org.fzzn.core.model.msg.Message<java.lang.String>
     * @author tian
     * @date 2022-4-20 15:36
     */
    @PostMapping("/evaluation/confirmOffer")
    public Message<String> confirmOffer(@RequestBody EvaluationReviewItemParam evaluationReviewItemParam) {
        return evaluationThirdService.confirmOffer(evaluationReviewItemParam);
    }


    /**
     * 查询专家报价信息提交状态
     *
     * @param evaluationReviewItemParam
     * @return org.fzzn.core.model.msg.Message<java.util.List < com.hb.core.pojo.project.evaluation.dto.EvaluationSecondDTO>>
     * @author tian
     * @date 2022-4-20 17:12
     */
    @PostMapping("/evaluation/selectOfferReview")
    public Message<List<EvaluationSecondDTO>> selectOfferReview(@RequestBody EvaluationReviewItemParam evaluationReviewItemParam) {
        return evaluationSecondService.selectOfferReview(evaluationReviewItemParam);
    }


    /**
     * 结束评标
     *
     * @param evaluationReviewItemParam
     * @return org.fzzn.core.model.msg.Message<java.lang.String>
     * @author tian
     * @date 2022-4-20 17:44
     */
    @PostMapping("/evaluation/endReview")
    public Message<String> endReview(@RequestBody EvaluationReviewItemParam evaluationReviewItemParam) {
        return evaluationSummaryService.endReview(evaluationReviewItemParam);
    }
    /**
     *
     * @Description:评标专家系统生成汇总表格
     * @Author: zhongdl
     * @Date:2022/4/22 9:52
     * @param evaluationSummaryAddDTO:
     * @return: {@link Message< Boolean> }
     **/
    @PostMapping("/evaluation/generateEvaluationSummary")
    public Message<Boolean> generateEvaluationSummary(@RequestBody EvaluationSummaryAddDTO evaluationSummaryAddDTO) {
        Long sectionId = evaluationSummaryAddDTO.getSectionId();

        EvaluationSummary evaluationSummaryBySectionId = evaluationSummaryService.getEvaluationSummaryBySectionId(sectionId);
        if (evaluationSummaryBySectionId != null && evaluationSummaryBySectionId.getId() != null){
            evaluationSummaryBySectionId.buildBaseData(2);
            boolean update = evaluationSummaryService.updateById(evaluationSummaryBySectionId);
            return MsgUtil.success(update);
        }
        BidSection bidSection = bidSectionService.getById(sectionId);
        if (bidSection == null){
            return MsgUtil.fail("标段信息不存下");
        }
        //生成评标报告和评标表格的状态
        EvaluationSummary evaluationSummary = new EvaluationSummary();
        evaluationSummary.buildBaseData(1);
        evaluationSummary.setSectionId(sectionId);
        evaluationSummary.setFileId(bidSection.getFileId());
        boolean save = evaluationSummaryService.save(evaluationSummary);
        return MsgUtil.success(save);
    }

    /**
     * 查询最终汇总详情
     *
     * @param evaluationReviewItemParam
     * @return org.fzzn.core.model.msg.Message<java.lang.String>
     * @author tian
     * @date 2022-4-20 17:44
     */
    @PostMapping("/evaluation/finalSummaryReview")
    public Message<Map> finalSummaryReview(@RequestBody EvaluationReviewItemParam evaluationReviewItemParam) {
        return evaluationSecondService.finalSummaryReview(evaluationReviewItemParam);
    }

    /**
     * 项目信息中的开标一览表
     * @param sectionParam
     * @return
     */
    @PostMapping("/evaluation/openingSchedule")
    public Message<EvaluationOpeningScheduleVO> openingSchedule(@RequestBody EvaluationBidSectionParam sectionParam) {
        EvaluationOpeningScheduleVO evaluationOpeningScheduleVO = evaluationService.openingSchedule(sectionParam.getSectionId());
        return MsgUtil.success(evaluationOpeningScheduleVO);
    }

}
